home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 4 / The 640 Meg Shareware Studio CD-ROM Volume IV (Data Express)(1994).ISO / wp / ehp10.zip / AUS_3.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  64KB  |  1,497 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  aus_3.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - do_control (Kontrollzeichen in Text einfg.)   */
  7. /*              - hndl_insert (Insert-Teil von do_inschar)      */
  8. /*              - hndl_overwrite (Overwrite-Teil von do_inschar)*/
  9. /*              - do_inschar (Zeichen in Text einfuegen)        */
  10. /*              - do_tog_tkm (Tabkomprimierungsmodus togglen)   */
  11. /*              - do_tog_bak (Backupfileerzeugungsmodus togglen)*/
  12. /*              - do_tog_ai (Autoindentmodus togglen)           */
  13. /*              - do_movewin (Fensterbewegung kontrollieren)    */
  14. /*              - do_toggle_size (Fenster auf gespeicherte Gr.) */
  15. /*              - do_sizewin (Fenstergroessenanpassung kontr.)  */
  16. /*              - do_swnext (Zum "Nachfolger" des akt. Fensters)*/
  17. /*              - do_swprev (Zum Vorgaenger des akt. Fensters)  */
  18. /*              - do_swnum (Window absolut anspringen)          */
  19. /*              - do_repeat (Funktion mehrmals ausfuehren)      */
  20. /*              - do_blstart (Blockanfang setzen)               */
  21. /*              - do_blnormend (Blockende (normal) setzen)      */
  22. /*              - do_blrechtend (Blockende (Rechteck) setzen)   */
  23. /*              - do_blunmark (Blockmarkierung loeschen)        */
  24. /*              - do_blweg (Block loeschen)                     */
  25. /*              - do_blcopy (Block kopieren)                    */
  26. /*              - do_blmove (Block verschieben)                 */
  27. /*              - do_blcut (Block in PASTE-Puffer kopieren)     */
  28. /*              - do_blpaste (PASTE-Puffer in Text einfuegen)   */
  29. /*              - do_blindent (Block einruecken)                */
  30. /*              - do_blread (Block einlesen)                    */
  31. /*              - do_blwrite (Block schreiben)                  */
  32. /*              - do_goblend (Zum Blockende gehen)              */
  33. /*              - do_goblanf (Zum Blockanfang gehen)            */
  34. /*              - do_bltofil (Block an Filter uebergeben)       */
  35. /*              - do_toghbl (Blockhervorhebungsmodus togglen)   */
  36. /*              - do_shelltog (Shellflag invertieren)           */
  37. /*              - do_setmarker (Marker setzen)                  */
  38. /*              - do_jumpmarker (Marker anspringen)             */
  39. /*              - do_lastpos (Letzte Position anspringen)       */
  40. /*              - do_swname (Window gemaess Name suchen)        */
  41. /*              - do_newname (Datei unter neuem Namen speichern)*/
  42. /*              - do_macro (Macro definieren/ausfuehren)        */
  43. /*              - do_restline (geloeschte Zeile wiederherstelen)*/
  44. /*              - auswertung (Tastendruck auswerten)            */
  45. /****************************************************************/
  46.  
  47. #include "defs.h"
  48. #include "keys.h"
  49.  
  50. void do_inschar();
  51.  
  52. extern char backupflag,highblockflag,clear_buff,bufflag;
  53. extern int schreib_file(),to_shell();
  54. extern short int letter,lastcode,aktcode,mc_index,taste();
  55. extern int save_delline(),rest_delline();
  56. extern int tst_overlap();
  57. extern char bufflag,*loadfile;
  58. extern bzeil_typ *save_normal(),*save_rechteck();
  59. extern block_typ global_block,*dup_block();
  60. extern puff_typ macro[],puff_feld[];
  61. extern int ks_index;
  62. extern short int *keystack,*e_keystack,newwgetch();
  63. extern WINDOW *status;
  64. extern marker_typ marker[];
  65. extern char *on_off[], /* Hilfstexte */
  66.                /* fuer Togglen der globalen Flags */
  67.         helpflag;  /* Flag: Hilfstexte anzeigen       */
  68.  
  69. extern void do_refresh(), do_bol(),do_eol(),do_halfup(),do_halfdn(),do_delete(),
  70.         do_backspace(),do_home(),do_nothome(),do_insovr(),do_textbeginn(),
  71.         do_eot(),do_del_word(),do_wleft(),do_wright(),do_right(),do_left(),
  72.         do_up(),do_down(),do_pgup(),do_pgdn(),do_newline(),do_delline(),
  73.         ueberschreiben(),do_schreib_file(),quit(),do_help(),laden(),
  74.         do_win_zu(),do_goto(),do_ende(),do_find(),do_replace(),
  75.         do_underline(),do_z_hoch(),do_z_runter(),do_z_oben(),
  76.         do_z_mitte(),do_z_unten(),do_deleol(),do_repfr(),do_repfr(),
  77.         do_join(),do_open(),do_tab(),do_settab(),do_hopen(),
  78.         do_backtab(),do_endemit(),quitmit(),do_find(), do_repfr(),
  79.         do_replace();
  80.  
  81.  
  82. /*****************************************************************************
  83. *
  84. *  Funktion       Kontrollzeichen in Text (do_control)
  85. *  --------
  86. *
  87. *  Beschreibung : Es wird ein Zeichen mit getch() eingelesen und ueber die
  88. *                 Funktion do_inschar in den Text plaziert.
  89. *
  90. *****************************************************************************/
  91.  
  92. void do_control()
  93. {
  94.   /* *** interne Daten, Initialisierung *** */
  95.  
  96.   if(letter = newwgetch(akt_winp->winp)) /* Ein Zeichen lesen. Nur wenn es */
  97.     do_inschar();                   /* nicht '\0' ist, wird es eingefuegt. */
  98. }
  99.  
  100.  
  101. /*****************************************************************************
  102. *
  103. *  Funktion       Insert-Teil von do_inschar behandeln (hndl_insert)
  104. *  --------
  105. *
  106. *  Paramater    : restn     :
  107. *                   Typ         : int *
  108. *                   Wertebereich: Pointer auf Integer
  109. *                   Bedeutung   : Anzahl der Zeichen, die noch einge-
  110. *                                 fuegt werden muessen
  111. *
  112. *  Ergebnis     :
  113. *                   Typ         : int
  114. *                   Wertebereich: TRUE, FALSE
  115. *                   Bedeutung   : TRUE: hat geklappt
  116. *                                 FALSE: hat nicht geklappt
  117. *
  118. *  Beschreibung : Es wird versucht, Platz fuer die einzufuegenden Zeichen
  119. *                 zu schaffen. Gelingt es nicht, ein einziges Zeichen ein-
  120. *                 zufuegen, wird eine neue Zeile eingefuegt. Je nachdem ob
  121. *                 die aktuelle Zeile am Ende aufgespalten wurde oder nicht
  122. *                 wird mit dem Einfuegen in der aktuellen oder der neuen
  123. *                 Zeile fortgefahren.
  124. *
  125. *****************************************************************************/
  126.  
  127. int hndl_insert(restn)
  128. int *restn;
  129. {
  130.   /* *** interne Daten *** */
  131.   int hilf;
  132.  
  133.   /* Anzahl eingefuegter Zeichen merken und von restn abziehen */
  134.   *restn -= (hilf = insert (*restn));
  135.   if (!hilf)        /* wenn keine Zeichen eingefuegt werden konnten   */
  136.   {
  137.     if (!new_line())     /* neue Zeile einfuegen */
  138.     {
  139.       print_err(T_SIZE_ERRTEXT); /* klappte das nicht, Meldung aus- */
  140.       return(FALSE);             /* geben und Funktion beenden      */
  141.     }
  142.     if (akt_winp->autoindflag)   /* Eventuell aufgespaltene Zeile   */
  143.       indent_line();             /* korrekt einruecken              */
  144.     if (akt_winp->alinep->text)  /* neue Zeile nicht leer?  */
  145.     {
  146.       up();                 /* in alte Zeile, da dort noch Platz */
  147.       eol();                        /* ans Ende */
  148.       if(insert(1))         /* wirklich noch Platz (kann nur  */
  149.       {
  150.     sw_ohne_refresh(W_AKT);
  151.     (*restn)--;         /* Fehler ergeben bei unterstr.Zchn.) ? */
  152.       }                     /* wenn nicht, schlaegt enter_char */
  153.     }                       /* fehl und do_newline wird aufgerufen */
  154.     else                    /* Wenn neue Zeile doch leer, testen ob */
  155.     {                       /* sich Cursor aus Fenster bewegt hat. */
  156.       if(akt_winp->ws_col > akt_winp->screencol) /* gegebenenfalls */
  157.     akt_winp->ws_col = akt_winp->screencol;  /* anpassen */
  158.       (*restn)--;           /* Neue Zeile ist leer, also kann ein */
  159.       sw_ohne_refresh(W_AKT);    /* Zeichen eingefuegt werden. */
  160.     } /* Fensterinhalt muss aber wegen eingefuegter Zeile neu */
  161.   }   /* angezeigt werden.                                    */
  162.   return(TRUE);
  163. }
  164.  
  165. /*****************************************************************************
  166. *
  167. *  Funktion       Overwrite-Teil von do_inschar behandeln (hndl_overwrite)
  168. *  --------
  169. *
  170. *  Paramater    : restn     :
  171. *                   Typ         : int *
  172. *                   Wertebereich: Pointer auf Integer
  173. *                   Bedeutung   : Anzahl der Zeichen, die noch einge-
  174. *                                 setzt werden muessen
  175. *
  176. *  Ergebnis     :
  177. *                   Typ         : int
  178. *                   Wertebereich: TRUE, FALSE
  179. *                   Bedeutung   : TRUE: hat geklappt
  180. *                                 FALSE: hat nicht geklappt
  181. *
  182. *  Beschreibung : Es wird getestet, ob Platz fuer die zu schreibenden Zeichen
  183. *                 vorhanden ist. Steht man am Zeilenende, wird versucht, in
  184. *                 die naechste Zeile zu gehen. Ist das nicht moeglich, wird
  185. *                 falls die maxlimale Zeilenanzahl noch nicht erreicht ist,
  186. *                 eine Zeile angehaengt. In der Zeile geht man an den Anfang.
  187. *                 Unterscheidet sich eines der zu ueberschreibenden Zeichen
  188. *                 von dem dazugehörigen einzusetzenden Zeichen in der Laenge
  189. *                 (eins unterstrichen, das andere nicht), dann werden alle
  190. *                 zu überschreibenden Zeichen gelöscht und für die neuen
  191. *                 Zeichen mit insert() Platz geschaffen.
  192. *
  193. *****************************************************************************/
  194.  
  195. int hndl_overwrite(restn)
  196. int *restn;
  197. {
  198.   /* *** interne Daten und Initialisierung *** */
  199.   char swflag = FALSE; /* Flag, ob Fenster neu zu zeichnen ist */
  200.   char u_diff=FALSE;   /* Flag: Einzutragendes Zeichen und zu überschrei- */
  201.                /* bendes Zeichen unterschiedlichen Unterstrcih-Mode */
  202.   int  anz_del=0,      /* Anzahl löschbarer Zeichen */
  203.        old_sc,         /* Zwischenspeicher Screencol */
  204.        old_tc;         /* Zwischenspeicher Textcol */
  205.  
  206.   if(akt_winp->screencol == MAXLENGTH) /* Steht man hinter Zeilenende? */
  207.   {
  208.     if(!down())      /* Eine Zeile runter. Klappt das nicht, dann */
  209.     {                /* testen, ob neue Zeile angehaengt werden kann */
  210.       if(akt_winp->maxline >= MAX_ANZ_LINES-1)
  211.       {
  212.     print_err(T_SIZE_ERRTEXT); /* wenn nein, Meldung ausgeben und raus */
  213.     return(FALSE);
  214.       }
  215.       koppel_line(); /* neue Zeile anhaengen. */
  216.       swflag = TRUE; /* Fensterinhalt ist neu zu zeichnen */
  217.     }
  218.     else
  219.       bol();           /* An den Anfang der Zeile springen */
  220.     if(akt_winp->ws_col)    /* Wenn erste Spalte nicht sichtbar, */
  221.     {                       /* dann sichtbar machen */
  222.       akt_winp->ws_col = 0;
  223.       swflag = TRUE;        /* Fensterinhalt muss neu gezeichnet werden */
  224.     }
  225.     if(swflag)
  226.       sw_ohne_refresh(W_AKT);
  227.   }
  228.  
  229.   fill_buff(); /* Zeile falls noch nicht drin, in Puffer kopieren */
  230.   old_tc = akt_winp->textcol;   /* Textcol und Screencol merken */
  231.   old_sc = akt_winp->screencol;
  232.   do
  233.   {
  234.     if(akt_winp->underflag ^ ul_char()) /* falls Zeichen verschiedene */
  235.                     /* Laengen haben */
  236.       u_diff = TRUE;  /* Merken, daß 2 Zeichen unterschiedlich waren */
  237.     anz_del++;        /* Anzahl zu löschender Zeichen inkrementieren */
  238.   } while (--(*restn) && right()); /* Solange wiederholen, bis alle */
  239.                /* Zeichen geprüft oder Zeilenende erreicht */
  240.   akt_winp->textcol = old_tc;    /* Textcol und Screencol restaurieren */
  241.   akt_winp->screencol = old_sc;
  242.  
  243.   if(u_diff)  /* Hatten 2 Zeichen unterschiedliche Länge ? */
  244.   {
  245.     mdelete(anz_del);       /* Zu überschreibende Zeichen loeschen */
  246.     insert(anz_del);        /* platz fuer neue Zeichen schaffen */
  247.   }
  248.   return(TRUE);
  249. }
  250.  
  251. /*****************************************************************************
  252. *
  253. *  Funktion       Zeichen in Text einfuegen (do_inschar)
  254. *  --------
  255. *
  256. *  Beschreibung : Entsprechend dem insflag wird das in letter stehende Zeichen
  257. *                 in den Text eingefuegt oder ueber den Text geschrieben.
  258. *
  259. *****************************************************************************/
  260.  
  261. void do_inschar()
  262. {
  263.   /* *** interne Daten und Initialisierung *** */
  264.   short    int input [INS_BUFF_LEN]; /* lokaler Eingabepuffer */
  265.   int          restn; /* Anzahl noch einzufuegender Zeichen   */
  266.   register int n=0,   /* Index in lokalen Eingabepuffer       */
  267.            nmax,  /* Anzahl eingelesener Zeichen          */
  268.            hilf;  /* Zum Einlesen einer Tastenkombination */
  269.  
  270.   nodelay (akt_winp->winp,TRUE); /* Tastatur soll -1 liefern, wenn keine */
  271.   do                             /* Taste gedrueckt wurde                */
  272.     input [n++] = letter;        /* Zeichen in Eingabepuffer uebernehmen */
  273.   while (n<INS_BUFF_LEN && (hilf=taste(akt_winp->winp)) == mc_index+1);
  274.   /* Wenn Puffer noch nicht voll, Tastenkombination lesen. Wenn es ein */
  275.   /* Zeichen ist, Aktion wiederholen.                                  */
  276.  
  277.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  278.   lastcode = hilf; /* Letzte gelesene Tastenkombination merken */
  279.   nmax = restn = n; /* Variablen anhand des "Pufferfuellstandes" initial. */
  280.   do
  281.   {
  282.     if (akt_winp->insflag)      /* Nur im Insert-Mode einfuegen */
  283.     {
  284.       if(!hndl_insert(&restn))  /* Einfuegung durchfuehren */
  285.     return;
  286.     }
  287.     else                          /* Sonst Ueberschreiben durchfuehren */
  288.       if(!hndl_overwrite(&restn)) /* Klappte Einfuegen oder Ueberschreiben */
  289.     return;                   /* nicht, dann Funktion verlassen */
  290.     while (enter_char((char) input [nmax-n]) /* Zeichen in Zeile einsetzen */
  291.     && --n>restn); /* Index in input anpassen */
  292.   } while (restn); /* Falls noch Zeichen einzufuegen sind, Aktion wiederholen */
  293.   setz_cursor(W_AKT);   /* Cursor an richtige Position setzen */
  294. }
  295.  
  296. /*****************************************************************************
  297. *
  298. *  Funktion       Tab-Komprimierungs-modus toggeln (do_tog_tkm)
  299. *  --------
  300. *
  301. *  Beschreibung : Der Status des Tab-Komprimierungs-modus wird invertiert.
  302. *                 Außerdem wird der Text als geändert markiert, damit er
  303. *                 abgespeichert wird. Das ist erforderlich, da sonst die
  304. *                 Datei evtl. das alte Format beibehält.
  305. *
  306. *****************************************************************************/
  307.  
  308. void do_tog_tkm()
  309. {
  310.   akt_winp->tabflag ^= TRUE;   /* Tabflagstatus togglen */
  311.   akt_winp->changeflag = TRUE; /* Text soll auf jeden Fall gespeichert werden */
  312.   setz_cursor(W_AKT);          /* Cursor wieder an richtige Position */
  313. }
  314.  
  315. /*****************************************************************************
  316. *
  317. *  Funktion       Backup-Funktion toggeln (do_tog_bak)
  318. *  --------
  319. *
  320. *  Beschreibung : Erzeugung eines .bak-Files wird aktiviert bzw. deaktiviert.
  321. *
  322. *****************************************************************************/
  323.  
  324. void do_tog_bak()
  325. {
  326.   print_stat(PROMPT_BACKUP);   /* Meldung ueber aktuellen Status */
  327.   print_stat(on_off[backupflag ^= TRUE]);  /* in der Statuszeile ausgeben    */
  328.   sleep(2);                                /* Warten, damit User Status lesen kann */
  329.   clear_stat();                            /* Statuszeile wieder loeschen */
  330.   setz_cursor(W_AKT);                           /* Cursor wieder an richtige Stelle */
  331. }
  332.  
  333. /*****************************************************************************
  334. *
  335. *  Funktion       Autoindent-modus toggeln (do_tog_ai)
  336. *  --------
  337. *
  338. *  Beschreibung : Der Status des Autoindent-modus wird invertiert.
  339. *
  340. *****************************************************************************/
  341.  
  342. void do_tog_ai()
  343. {
  344.   akt_winp->autoindflag ^= TRUE;  /* Autoindentflag togglen */
  345.   setz_cursor(W_AKT);                  /* Cursor wieder an richtige Position setzen */
  346. }
  347.  
  348.  
  349. /*****************************************************************************
  350. *
  351. *  Funktion       Fensterbewegung kontrollieren (do_movewin)
  352. *  --------
  353. *
  354. *  Beschreibung : Es werden die Ecken des Fensters angezeigt. Anschliessend
  355. *                 wird eine Nutzereingabe ausgewertet, aus der die Bewe-
  356. *                 gunsrichtung entnommen wird. Beendet der Benutzer die
  357. *                 Bewegung, so wird do_refresh() aufgerufen, um das Fenster
  358. *                 an der neuen Position zu zeigen.
  359. *
  360. *****************************************************************************/
  361.  
  362. void do_movewin()
  363. {
  364.   /* *** interne Daten und Initialisierung *** */
  365.   register short int c,  /* Zum Einlesen einer Taste */
  366.              d;  /* Zum Einlesen einer '\0'.. Sequenz */
  367.   int step = SW_STEP,    /* Schrittweite beim Verschieben */
  368.       i;                 /* Zaehler fuer Verschieben mit step != 1 */
  369.  
  370.   werase (akt_winp->winp);  /* Fensterinhalt auf Bildschirm loeschen */
  371.   wrefresh(akt_winp->winp); /* damit kein Fehler beim Verschieben passiert */
  372.   cpwins2stdscr(); /* Alle Fenster ausser akt. nach stdscr kopieren */
  373.   do
  374.   {
  375.     mvprintw(LINES-1,0,PROMPT_WINMOVE,step);
  376.     eckenhw();                 /* Ecken des Fensters markieren         */
  377.     c = newwgetch(stdscr);     /* Ein Zeichen von Tastatur / Macro lesen */
  378.     eckenhw();                 /* Ecken vor Verschieben loeschen       */
  379.     if(c == 's')               /* Bei 's' Schrittweite anpassen */
  380.       step = step == SW_STEP ? 1 : SW_STEP; /* war's 1, dann SW_STEP und umgekehrt */
  381.     else                       /* Sonst <step> mal in angegebene Richtung */
  382. #ifdef OS2  /* Bei OS/2 kein zweites Zeichen lesen! */
  383.     {
  384.       d = c;
  385. #else
  386.       if(c==(short int) '\0')              /* "Escape"-Kombination ? */
  387.       {
  388.     d = newwgetch(stdscr); /* Dann nächstes Zeichen lesen */
  389. #endif
  390.     for(i=0;i<step;i++)      /* verschieben */
  391.       switch (d)
  392.       {
  393.         case KEY_RIGHT : win_right(1); break;
  394.         case KEY_LEFT  : win_left(1);  break;
  395.         case KEY_UP    : win_up(1);    break;
  396.         case KEY_DOWN  : win_down(1);  break;
  397.       }
  398.       } /* Achtung!!! Diese Klammer gehört zum else für OS2, zu if sonst */
  399.   } while (c != END_KEY);      /* Solange wiederholen, bis beendende Taste */
  400.   erase();refresh();           /* gedrueckt wurde (RETURN) */
  401.   mvwin (akt_winp->winp,akt_winp->y,akt_winp->x); /* Fenster verschieben */
  402.   do_refresh();                   /* Alle Fenster neu zeichnen              */
  403. }
  404.  
  405. /*****************************************************************************
  406. *
  407. *  Funktion       Fenster auf gespeicherte Groesse bringen (do_toggle_size)
  408. *  --------
  409. *
  410. *  Beschreibung : Die in der Windowstruktur gespeicherten alten Groessen
  411. *                 und Fensterposition werden mit den aktuellen vertauscht.
  412. *                 Die Cursorposition wird eventuell angepasst. Danach wird
  413. *                 ein do_refresh() ausgefuehrt.
  414. *
  415. *****************************************************************************/
  416.  
  417. void do_toggle_size()
  418. {
  419.   toggle_size();   /* Alte Fensterkoordinaten mit neuen besetzen und umgekehrt */
  420.   do_refresh();    /* Alle Fenster neu zeichnen */
  421. }
  422.  
  423. /*****************************************************************************
  424. *
  425. *  Funktion       Fenstergroessenanpassung kontrollieren (do_sizewin)
  426. *  --------
  427. *
  428. *  Beschreibung : Die Ecken des Fensters werden angezeigt. Dann wird eine
  429. *                 Nutzereingabe ausgewertet, aus der die Bewegungs-
  430. *                 richtung der rechten unteren Fensterecke entnommen wird.
  431. *                 Wird die Groessenanpassung beendet, werden alle Fenster
  432. *                 refresht (do_refresh()).
  433. *
  434. *****************************************************************************/
  435.  
  436. void do_sizewin()
  437. {
  438.   /* *** interne Daten *** */
  439.   register short int c, /* Zum Einlesen einer Taste */
  440.              d; /* Zum Einlesen einer '\0'.. Sequenz */
  441.   int step = SW_STEP,   /* Schrittweite beim Groessenveraendern */
  442.       i;                /* Zahler beim Veraendern mit step != 1 */
  443.  
  444.   werase (akt_winp->winp);  /* Fensterinhalt auf Bildschirm loeschen,     */
  445.   wrefresh(akt_winp->winp); /* damit keine Fehler beim Anpassen auftreten */
  446.   cpwins2stdscr(); /* Alle Fenster ausser akt. nach stdscr kopieren */
  447.   do
  448.   {
  449.     mvprintw(LINES-1,0,PROMPT_WINSIZE,step);
  450.     eckenhw();              /* Fenstereckpunkte merkieren */
  451.     c = newwgetch(stdscr);  /* Zeichen von Tastatur / Macro einlesen */
  452.     eckenhw();              /* Fenstereckpunkte vor Verschieben loeschen */
  453.     if(c == 's')            /* Bei 's' Schrittweite aendern : */
  454.       step = step == SW_STEP ? 1 : SW_STEP; /* war step 1, dann SW_STEP und */
  455.     else                                    /* umgekehrt                    */
  456. #ifdef OS2  /* Bei OS/2 kein zweites Zeichen lesen! */
  457.       d = c;
  458. #else
  459.       if(c==(short int) '\0')              /* "Escape"-Kombination ? */
  460.       {
  461.     d = newwgetch(stdscr); /* Dann nächstes Zeichen lesen */
  462. #endif
  463.     for(i=0;i<step;i++)   /* <step> mal in angegebene Richtung vergroessern */
  464.       switch (d)
  465.       {
  466.         case KEY_RIGHT : size_right(1); break;
  467.         case KEY_LEFT  : size_left(1);  break;
  468.         case KEY_UP    : size_up(1);    break;
  469.         case KEY_DOWN  : size_down(1);  break;
  470.       }
  471. #ifndef OS2
  472.       }
  473. #endif
  474.   } while (c != END_KEY);   /* Solange wiederholen, bis beendende Taste */
  475.   erase();                  /* gedrueckt wurde (RETURN) */
  476.   refresh();                /* Fensterinhalt loeschen */
  477.   delwin(akt_winp->winp);   /* Fenster mit Curses loeschen und neu anlegen */
  478.   akt_winp->winp=newwin(akt_winp->dy+2,akt_winp->dx+2,akt_winp->y,akt_winp->x);
  479.   init_win();               /* Fensterattribute setzen (raw etc.) */
  480.  
  481.   /* Falls Cursor jetzt ausserhalb des Fensters steht, Cursorposition anpassen */
  482.   if (akt_winp->ws_line+akt_winp->dy <= akt_winp->textline)
  483.     gotox(akt_winp->ws_line+akt_winp->dy-1);
  484.   if (akt_winp->ws_col+akt_winp->dx <= akt_winp->screencol)
  485.     akt_winp->screencol = akt_winp->ws_col+akt_winp->dx-1;
  486.   do_refresh();  /* Alle Fenster neu zeichnen */
  487. }
  488.  
  489. /*****************************************************************************
  490. *
  491. *  Funktion       Zum Nachfolger des aktuellen Fensters (do_swnext)
  492. *  --------
  493. *
  494. *  Beschreibung : Das Fenster, das hinter dem Dummyelement steht, wird
  495. *                 hinter dem aktuellen Fenster eingefuegt. Das Element hinter
  496. *                 dem aktuellen Fenster wird dann zum aktuellen Fenster.
  497. *
  498. *****************************************************************************/
  499.  
  500. void do_swnext()
  501. {
  502.   /* *** interne Daten *** */
  503.   win_typ *hilf,  /* Zeiger fuer erstes Fester in Liste */
  504.       *dummy; /* Zeiger fuer leeres Element in der Fensterliste */
  505.  
  506.   if (akt_winp->next->next == akt_winp) /* Test, ob nur ein Fenster */
  507.   {
  508.     print_err(PROMPT_ONEWINDOW); /* Wenn ja, Meldung und Ende */
  509.     return;
  510.   }
  511.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  512.   rahmen(W_NOTAKT);
  513.   wrefresh(akt_winp->winp);
  514.  
  515.   check_buff();              /* Sonst evtl. Pufferinhalt in Text eintragen */
  516.   dummy = akt_winp->next;    /* dummy auf leeres Element der Liste setzen  */
  517.   hilf = dummy->next;        /* hilf auf erstes Fenster in Liste setzen    */
  518.   dummy->next = hilf->next;
  519.   dummy->prev = hilf;        /* Dummyfenstereintrag vor hilf einkoppeln,   */
  520.   dummy->next->prev = dummy; /* da aktuelles Fenster immer am Listenende   */
  521.   akt_winp->next = hilf;     /* stehen muss.                               */
  522.   hilf->prev = akt_winp;
  523.   hilf->next = dummy;
  524.   akt_winp = hilf;           /* hilf wird zum aktuellen Fenster            */
  525.   show_win(W_AKT);           /* Aktuellen Fensterinhalt neu zeichnen       */
  526. }
  527.  
  528. /*****************************************************************************
  529. *
  530. *  Funktion       Zum Vorgaenger des aktuellen Fensters (do_swprev)
  531. *  --------
  532. *
  533. *  Beschreibung : Das aktuelle Fenster, das vor dem Dummyelement steht, wird
  534. *                 hinter dem Dummy-Element eingefuegt. Das Element vor dem
  535. *                 aktuellen Fenster wird dann zum aktuellen Fenster. Man
  536. *                 kommt also ueber diese Funktion in das Fenster, das un-
  537. *                 mittelbar vor dem aktuellen Fenster geoeffnet wurde.
  538. *
  539. *****************************************************************************/
  540.  
  541. void do_swprev()
  542. {
  543.   /* *** interne Daten *** */
  544.   win_typ *hilf,    /* zeigt auf Vorgaenger des aktuell werdenden Fensters */
  545.       *old_akt; /* Zeiger fuer Fenster, das beim Aufruf aktuell war */
  546.  
  547.   if (akt_winp->next->next == akt_winp) /* Test, ob nur ein Fenster da    */
  548.   {
  549.     print_err(PROMPT_ONEWINDOW); /* Wenn ja, Meldung und raus */
  550.     return;
  551.   }
  552.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  553.   rahmen(W_NOTAKT);
  554.   wrefresh(akt_winp->winp);
  555.  
  556.   check_buff();                          /* Pufferinhalt in Text sichern   */
  557.   akt_winp = (old_akt = akt_winp)->prev; /* old_akt und akt_winp setzen    */
  558.   akt_winp->next = old_akt->next;        /* Aktuelles Fenster wird mit dem */
  559.   hilf = akt_winp->prev;                 /* vor ihm stehenden vertauscht   */
  560.   akt_winp->prev = old_akt;
  561.   old_akt->prev = hilf;
  562.   hilf->next = old_akt;
  563.   akt_winp->next->prev = akt_winp;
  564.   old_akt->next = akt_winp;
  565.   show_win(W_AKT);                        /* Fensterinhalt neu zeichnen     */
  566. }
  567.  
  568. /*****************************************************************************
  569. *
  570. *  Funktion       Window absolut anspringen (do_swnum)
  571. *  --------
  572. *
  573. *  Beschreibung : Der Nutzer kann eine Fensternummer eingeben. Falls die
  574. *                 Nummer existiert, wird das Fenster mit dieser Nummer
  575. *                 zum aktuellen Fenster.
  576. *
  577. *****************************************************************************/
  578.  
  579. void do_swnum()
  580. {
  581.   /* *** interne Daten *** */
  582.   char num_str [3];  /* String fuer einzulesende Fensternummer */
  583.   int  num;          /* eingelesene Nummer als Integer         */
  584.  
  585.   print_stat (PROMPT_WINDOWNUM);
  586.   read_stat (num_str,2,GS_NUM);    /* Nummer einlesen, nur 2 Ziffern erlaubt */
  587.   clear_stat();                    /* Statuszeile wieder loeschen            */
  588.   check_buff();                    /* Pufferinhalt in Text uebernehmen       */
  589.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  590.   rahmen(W_NOTAKT);
  591.   wrefresh(akt_winp->winp);
  592.  
  593.   /* String in Integer umwandeln. Test, ob Nummer == 0 oder aktuelle Fnstnr. */
  594.   if ((num = atoi (num_str)) && num != akt_winp->wini)
  595.     if(make_akt_win(num)) /* Wenn alles in Ordnung, versuchen, gewuenschtes  */
  596.       show_win(W_AKT);         /* Fenster zum aktuellen zu machen. Klappte das,   */
  597.     else                  /* Fensterinhalt neu zeichnen, sonst Meldung       */
  598.     {
  599.       pe_or (PROMPT_WINNMNFND);
  600.       rahmen(W_AKT); /* Doch wieder aktiv, kopf kommt von setz_cursor */
  601.       setz_cursor(W_AKT);
  602.     }
  603.   else                    /* Fehler bei Nummer, dann nur Cursor plazieren    */
  604.     setz_cursor(W_AKT);
  605. }
  606.  
  607. /*****************************************************************************
  608. *
  609. *  Funktion       Funktion mehrmals ausfuehren (do_repeat)
  610. *  --------
  611. *
  612. *  Beschreibung : Der User muss die Anzahl der Wiederholungen eingeben.
  613. *                 Anschliessend,falls die eingegebene Anzahl groesser 0 war,
  614. *                 wird ein Kommando eingelesen, welches dann von der Funktion
  615. *                 taste so oft zurueckgegeben wird, wie der User spezifizierte.
  616. *
  617. *****************************************************************************/
  618.  
  619. void do_repeat()
  620. {
  621.   /* *** interne Daten *** */
  622.   char zahl_str[6];  /* String fuer Anzahl der Wiederholungen */
  623.   int  i;            /* Stringinhalt als Integer */
  624.  
  625.   if(ks_index < MACRO_NEST_DEPTH - 1) /* Testen, ob noch ein Puffer frei */
  626.   {                                   /* Wenn ja, Wiederholungsanzahl einlesen */
  627.     print_stat(PROMPT_REPEAT);
  628.     read_stat(zahl_str,5,GS_NUM);
  629.     clear_stat();                     /* Statuszeile wieder loeschen */
  630.     if ((i=atoi(zahl_str)) > 0)       /* String nach Integer, muss > 0 sein */
  631.     {
  632.       /* Mit get_comstr wird eine Befehlsfolge von der Tastatur eingelesen */
  633.       /* und im ersten freien Puffer (ks_index+1) abgelegt.                */
  634.       get_comstr(&puff_feld[ks_index+1].begin,&puff_feld[ks_index+1].end);
  635.       if(puff_feld[ks_index+1].begin)    /* keine Leereingabe? */
  636.       {
  637.     if(ks_index >=0)              /* Wenn schon ein Puffer aktiv, dann  */
  638.       puff_feld[ks_index].current = keystack; /* Position darin merken  */
  639.     keystack = puff_feld[++ks_index].begin; /* Position im neuen setzen */
  640.             /* Puffer soll nach Ausfuehrung der Wiederholung wieder */
  641.     puff_feld[ks_index].free_flag = TRUE;         /* freigegeben werden */
  642.     e_keystack = puff_feld[ks_index].end; /* Pufferende merken          */
  643.     puff_feld[ks_index].anz_rep = i - 1;  /* Anzahl der Wdh. eintragen  */
  644.       }
  645.     }
  646.     setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  647.   }
  648.   else      /* falls kein Puffer mehr frei, Fehlermeldung ausgeben */
  649.   {
  650.     clear_buff = TRUE;  /* beim naechsten Aufruf von newwgetch() Puffer loeschen */
  651.     print_err(PROMPT_RECURSION);
  652.   }
  653. }
  654.  
  655. /*****************************************************************************
  656. *
  657. *  Funktion       Blockanfang an aktueller Position setzen (do_blstart)
  658. *  --------
  659. *
  660. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  661. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  662. *                 kein Blockende definiert wurde - der Blockstart festgelegt.
  663. *                 War schon ein Blockende vorhanden, so wird show_win(W_AKT)
  664. *                 aufgerufen.
  665. *
  666. *****************************************************************************/
  667.  
  668. void do_blstart()
  669. {
  670.   akt_winp->block.s_line = akt_winp->textline;  /* Zeile und Spalte als Block- */
  671.   akt_winp->block.s_col = akt_winp->screencol;  /* eintragen */
  672.   if(highblockflag)                    /* Falls Block gehighlighted sein soll, */
  673.     show_win(W_AKT);                        /* markierten Block anzeigen */
  674. }
  675.  
  676. /*****************************************************************************
  677. *
  678. *  Funktion       Blockende (normal) an aktueller Position setzen (do_blnormend)
  679. *  --------
  680. *
  681. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  682. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  683. *                 kein Blockanfang definiert wurde - das Blockende festgelegt.
  684. *                 War schon ein Blockanfang vorhanden, so wird show_win(W_AKT)
  685. *                 aufgerufen.
  686. *
  687. *****************************************************************************/
  688.  
  689. void do_blnormend()
  690. {
  691.   akt_winp->block.e_line = akt_winp->textline; /* Zeile und Spalte als Block- */
  692.   akt_winp->block.e_col = akt_winp->screencol; /* ende eintragen              */
  693.   akt_winp->block.typ = BT_NORMAL;             /* Blocktyp eintragen          */
  694.   if(highblockflag)  /* Falls Block gehighlighted dargestellt werden soll,    */
  695.     show_win(W_AKT);      /* Fenstrinhalt neu darstellen */
  696. }
  697.  
  698. /*****************************************************************************
  699. *
  700. *  Funktion       Blockende (Rechteck) an aktueller Position setzen (do_blrechtend)
  701. *  --------
  702. *
  703. *  Beschreibung : An der aktuellen Cursorposition wird - falls zulaessig, d.h.
  704. *                 falls der Blockanfang vor dem Blockende liegt oder noch
  705. *                 kein Blockanfang definiert wurde - das Blockende festgelegt.
  706. *                 War schon ein Blockanfang vorhanden, so wird show_win(W_AKT)
  707. *                 aufgerufen.
  708. *
  709. *****************************************************************************/
  710.  
  711. void do_blrechtend()
  712. {
  713.   akt_winp->block.e_line = akt_winp->textline;  /* Aktuelle Zeile und Spalte */
  714.   akt_winp->block.e_col = akt_winp->screencol;  /* als Blockende eintragen   */
  715.   akt_winp->block.typ = BT_RECHTECK;            /* Blocktyp eintragen        */
  716.   if(highblockflag) /* Falls Block gehighlighted dargestellt werden soll,    */
  717.     show_win(W_AKT);     /* Fenstrinhalt neu darstellen */
  718. }
  719.  
  720. /*****************************************************************************
  721. *
  722. *  Funktion       Blockmarkierung loeschen (do_blunmark)
  723. *  --------
  724. *
  725. *  Beschreibung : Die Blockmarkierungen werden geloescht und ein show_win(W_AKT)
  726. *                 durchgefuehrt, um eventuelle Blockmarkierungen auf dem
  727. *                 Schirm zu loeschen.
  728. *
  729. *****************************************************************************/
  730.  
  731. void do_blunmark()
  732. {
  733.   if(block_defined())   /* Wenn ein Block markiert ist         */
  734.     if(tst_overlap())   /* und dieser im Fenster sichtbar ist, */
  735.     {                   /* Blockgrenzen loeschen und           */
  736.       akt_winp->block.e_line = akt_winp->block.s_line = -1;
  737.       show_win(W_AKT);       /* Fensterinhalt neu zeichnen          */
  738.     }
  739.     else    /* Ist der Block nicht im Fenster, dann nur die Grenzen loeschen */
  740.       akt_winp->block.e_line = akt_winp->block.s_line = -1;
  741. }
  742.  
  743. /*****************************************************************************
  744. *
  745. *  Funktion       Block loeschen (do_blweg)
  746. *  --------
  747. *
  748. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  749. *                 der Block geloescht, die Cursor- und Bildschirmposition an-
  750. *                 gepasst und evtl. der Bildschirm neu gezeichnet.
  751. *
  752. *****************************************************************************/
  753.  
  754. void do_blweg()
  755. {
  756.   if (block_defined())  /* Nur ausfuehren, wenn ein Block definiert ist */
  757.   {
  758.     /* In laenge wird die Differenz der letzten und der ersten Zeile */
  759.     /* eingetragen */
  760.     akt_winp->block.laenge = akt_winp->block.e_line-akt_winp->block.s_line;
  761.     if (akt_winp->block.typ == BT_RECHTECK)   /* Abhaengig vom Blocktyp wird */
  762.       del_rechteck();                         /* entweder del_rechteck oder  */
  763.     else                                      /* del_normal aufgerufen       */
  764.     {
  765.       del_normal();
  766.       if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  767.     akt_winp->ws_line = akt_winp->textline;    /* Loeschen des Blocks     */
  768.       if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  769.     akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  770.     }   /* Anschliessend die Blockgrenzen loeschen */
  771.     akt_winp->block.e_line = akt_winp->block.s_line = -1;
  772.     show_win(W_AKT); /* Fensterinhalt neu zeichnen */
  773.   }
  774. }
  775.  
  776. /*****************************************************************************
  777. *
  778. *  Funktion       Block kopieren (do_blcopy)
  779. *  --------
  780. *
  781. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  782. *                 der Block in einen Puffer kopiert und dieser dann an der
  783. *                 aktuellen Position eingefuegt.  Danach wird der Puffer frei-
  784. *                 gegeben und evtl. der Bildschirm neu gezeichnet.
  785. *
  786. *****************************************************************************/
  787.  
  788. void do_blcopy()
  789. {
  790.   /* *** interne Daten *** */
  791.   int ok;  /* Zwischenspeicher fuer Rueckgabewert der Insert-Funktionen */
  792.  
  793.   if (block_defined())  /* Nur ausfuehren, falls ein Block markiert ist */
  794.   {
  795.     if (akt_winp->block.typ == BT_RECHTECK)     /* Abhaengig vom Blocktyp */
  796.     {                                           /* entweder save_rechteck */
  797.       akt_winp->block.bstart = save_rechteck(); /* und ins_rechteck auf-  */
  798.       ok = ins_rechteck(&akt_winp->block);      /* rufen oder             */
  799.     }
  800.     else
  801.     {
  802.       akt_winp->block.bstart = save_normal();   /* save_normal und ins_normal */
  803.       ok = ins_normal(&akt_winp->block);        /* aufrufen */
  804.     }
  805.     block_free(akt_winp->block.bstart);         /* Blocktext freigeben        */
  806.     show_win(W_AKT);                                 /* Fensterinhalt neu anzeigen */
  807.     if(!ok)                                     /* Falls beim Einfuegen ein   */
  808.       print_err(B_SIZE_ERRTEXT);                /* Fehler auftrat, Meldung    */
  809.   }
  810. }
  811.  
  812. /*****************************************************************************
  813. *
  814. *  Funktion       Block verschieben (do_blmove)
  815. *  --------
  816. *
  817. *  Beschreibung : Falls ein Block markiert ist, wird er kopiert, geloescht
  818. *                 und an der aktuellen Cursorposition wieder eingefuegt.
  819. *
  820. *****************************************************************************/
  821.  
  822. void do_blmove()
  823. {
  824.   /* *** interne Daten *** */
  825.   int old_sc,  /* Zwischenspeicher fuer Spalte falls Einfuegen nicht klappt */
  826.       old_tl;  /* Zwischenspeicher fuer Zeile falls Einfuegen nicht klappt */
  827.  
  828.   if (block_defined()) /* Nur ausfuehren, wenn ein Block maekiert ist */
  829.   {
  830.     if (akt_winp->block.typ == BT_RECHTECK)  /* Blocktyp ermitteln */
  831.     {
  832.       akt_winp->block.bstart = save_rechteck();  /* Blocktext abspeichern    */
  833.       del_rechteck();                            /* Block im Text loeschen   */
  834.       if(!ins_rechteck(&akt_winp->block))        /* Block an aktueller       */
  835.       {                                          /* Position einfuegen       */
  836.     old_sc = akt_winp->screencol;            /* klappt das nicht, dann   */
  837.     old_tl = akt_winp->textline;             /* Position merken,         */
  838.     akt_winp->screencol = akt_winp->block.s_col; /* zum Anfang des alten */
  839.     gotox(akt_winp->block.s_line);  /* Blocks gehen und dort wieder hin. */
  840.     ins_rechteck(&akt_winp->block); /* Einfuegen an alter position muss  */
  841.     akt_winp->screencol = old_sc;   /* funktionieren. Cursorposition     */
  842.     gotox(old_tl);                  /* restaurieren                      */
  843.     print_err(B_SIZE_ERRTEXT);      /* Fehlermeldung ausgeben            */
  844.       }
  845.       else
  846.     show_win(W_AKT); /* Klappte Einfuegen, dann Fensterinhalt neu anzeigen */
  847.     }
  848.     else                                /* Normaler Block: */
  849.       if (akt_winp->maxline + 2 < MAX_ANZ_LINES) /* Test ob genug Zeilen frei */
  850.       {
  851.     akt_winp->block.bstart = save_normal(); /* Wenn ja, Blocktext merken, */
  852.     del_normal();                           /* Block im Text loeschen     */
  853.     ins_normal(&akt_winp->block);           /* An aktueller Pos. einfuegen*/
  854.     if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  855.       akt_winp->ws_line = akt_winp->textline;    /* Verschieben des Blocks  */
  856.     if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  857.       akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  858.     show_win(W_AKT);                             /* Fensterinhalt neu anzeigen */
  859.       }
  860.       else       /* Waren nicht genuegend Zeilen frei, Fehlermeldung ausgeben */
  861.     print_err(B_SIZE_ERRTEXT);
  862.     block_free(akt_winp->block.bstart);   /* Blocktext freigeben */
  863.   }
  864. }
  865.  
  866. /*****************************************************************************
  867. *
  868. *  Funktion       Block cutten (do_blcut)
  869. *  --------
  870. *
  871. *  Beschreibung : Falls ein Block markiert ist, wird in Abhaengigkeit vom Typ
  872. *                 der Block in einen Puffer, den sogenannten PASWTE-Puffer,
  873. *                 kopiert. Dieser kann mit der Paste-Funktion ino einem belie-
  874. *                 bigen Fenster eingefuegt werden.
  875. *
  876. *****************************************************************************/
  877.  
  878. void do_blcut()
  879. {
  880.   if (block_defined())      /* Nur ausfuehren, falls ein Block definiert ist */
  881.   {
  882.     if(global_block.bstart) /* Steht schon ein Block im Paste-Puffer, muss */
  883.       block_free(global_block.bstart);       /* dieser freigegeben werden. */
  884.     if (akt_winp->block.typ == BT_RECHTECK)  /* abhaengig vom Blocktyp die */
  885.       akt_winp->block.bstart = save_rechteck(); /* entsprechende Funktion zum */
  886.     else                                        /* Abspeichern des Blockes    */
  887.       akt_winp->block.bstart = save_normal();   /* verwenden                  */
  888.     show_win(W_AKT);                                 /* Fenster neu anzeigen       */
  889.     memcpy(&global_block,&akt_winp->block,sizeof(block_typ)); /* Daten des akt. */
  890.     print_stat(PROMPT_CUT); /* Blocks kopieren  */
  891.     sleep(1);                           /* Meldung ausgeben und 2 Sek. warten */
  892.     clear_stat();                       /* Meldung wieder loeschen */
  893.     setz_cursor(W_AKT);                      /* Cursor an richtige Position */
  894.   }
  895. }
  896.  
  897. /*****************************************************************************
  898. *
  899. *  Funktion       Block pasten (do_blpaste)
  900. *  --------
  901. *
  902. *  Beschreibung : Falls mit der cut-Funktion ein Block in den PASTE-Puffer ko-
  903. *                 piert wurde, wird dieser im aktuellen Fenster an der Cursor-
  904. *                 position eingefuegt.
  905. *
  906. *****************************************************************************/
  907.  
  908. void do_blpaste()
  909. {
  910.   /* *** interne Daten *** */
  911.   block_typ *hilf;  /* Zeiger fuer duplizierten Paste-Block */
  912.   int       ok;     /* Rueckgabewert der Insert-Funktionen */
  913.  
  914.   if (global_block.bstart)              /* Nur, wenn Paste-Puffer belegt */
  915.   {
  916.     if (akt_winp->maxline == -1)        /* Falls Text leer, Eine Zeile anlegen, */
  917.       koppel_line(IGNORE_COORS);        /* da sonst Dummy ueberschrieben wird.  */
  918.     /* Marker und lastpos sind im leeren Text egal */
  919.     hilf = dup_block(&global_block);    /* Blocktext duplizieren */
  920.     if (global_block.typ == BT_RECHTECK) /* Abhaengig vom Typ ins_rechteck */
  921.       ok = ins_rechteck(hilf);           /* oder ins_normal aufrufen       */
  922.     else
  923.       ok = ins_normal(hilf);
  924.     if(ok) /* Wenn ins_normal bzw. ins_rechteck geklappt haben, */
  925.       show_win(W_AKT);  /* Fensterinhalt neu anzeigen */
  926.     else   /* Klappte des Einfuegen nicht, Fehlermeldung ausgeben. */
  927.       print_err(B_SIZE_ERRTEXT);
  928.     block_free(hilf->bstart);     /* Blocktext des aktuellen Blocks freigeben */
  929.     free (hilf);                  /* Hilfsblockstruktur freigeben */
  930.   }
  931. }
  932.  
  933. /*****************************************************************************
  934. *
  935. *  Funktion       Block einruecken (do_blindent)
  936. *  --------
  937. *
  938. *  Beschreibung : Falls ein Block markiert wurde, werden alle Zeilen ab der
  939. *                 Blockstartzeile bis zur Blockendezeile um einen vom Nutzer
  940. *                 einzugebenden Wert eingerueckt. Dabei entscheidet das Vor-
  941. *                 zeichen ueber die Einrueckungsrichtung.
  942. *
  943. *****************************************************************************/
  944.  
  945. void do_blindent()
  946. {
  947.   /* *** interne Daten *** */
  948.   int  weite;         /* Eingelesene Weite als Integer */
  949.   char weit_str[10];  /* Eingelesene Weite als String  */
  950.  
  951.   if (block_defined())  /* Nur ausfuehren, falls ein Block markiert ist */
  952.   {
  953.     print_stat(PROMPT_ASKINDENT);
  954.     read_stat(weit_str,9,GS_ANY);  /* Weite als String einlesen              */
  955.     clear_stat();                  /* Statuszeile wieder loeschen            */
  956.     setz_cursor(W_AKT);                 /* Cursor wieder an richtige Position     */
  957.     if (weite = atoi(weit_str))    /* String in int wandeln und auf 0 testen */
  958.       if (indent_block(weite))     /* Weite != 0, dann Block einruecken      */
  959.     show_win(W_AKT);                /* und Fensterinhalt neu anzeigen         */
  960.   }
  961.   else                             /* War kein Block markiert, Meldung ausgeben */
  962.     print_err(PROMPT_NOBLOCK);
  963. }
  964.  
  965. /*****************************************************************************
  966. *
  967. *  Funktion       Block einlesen (do_blread)
  968. *  --------
  969. *
  970. *  Beschreibung : Eine vom Nutzer anzugebende Datei wird an der aktuellen
  971. *                 Cursorposition in den Text eingefuegt und als Block mar-
  972. *                 kiert.
  973. *
  974. *****************************************************************************/
  975.  
  976. void do_blread()
  977. {
  978.   /* *** interne Daten *** */
  979.   char name[MAXLENGTH+1];  /* Array fuer einzulesenden Dateinamen */
  980.   FILE *f;                 /* Filepointer fuer zu lesende Datei */
  981.  
  982.   print_stat(PROMPT_FILENAME);
  983.   read_stat(name,MAXLENGTH,GS_ANY);  /* Dateiname einlesen */
  984.   clear_stat();                      /* Statuszeile wieder loeschen */
  985.   setz_cursor(W_AKT);                     /* Cursor an alte Position */
  986.   if(name[0])                        /* Nur ausfuehren, wenn Name vorhanden */
  987.     if (f=fopen(name,"r"))           /* Datei zum Lesen oeffnen */
  988.     {
  989.       akt_winp->block.typ = BT_NORMAL;     /* Blocktyp eintragen */
  990.       if(lies_block(&akt_winp->block,f))   /* Block aus Datei lesen */
  991.       {                                    /* Klappte das, dann Block in */
  992.     if(!ins_normal(&akt_winp->block))  /* Text einfuegen. Falls Fehler */
  993.       print_err(B_SIZE_ERRTEXT);       /* beim Einfuegen, dann Meldung */
  994.     else                               /* Sonst Fensterinhalt neu */
  995.       show_win(W_AKT);                      /* anzeigen */
  996.     block_free(akt_winp->block.bstart);/* Blocktext freigeben */
  997.     fclose (f);
  998.       }
  999.       else                                 /* lies_block lieferte FALSE, */
  1000.     print_err(PROMPT_BLOCKEMPT);       /* Meldung, dass Block leer */
  1001.     }
  1002.     else                                   /* Falls Datei nicht geoeffnet */
  1003.       print_err(PROMPT_FILENOTFD);         /* werden konnte, Meldung */
  1004. }
  1005.  
  1006. /*****************************************************************************
  1007. *
  1008. *  Funktion       Block schreiben (do_blwrite)
  1009. *  --------
  1010. *
  1011. *  Beschreibung : Falls ein Block markiert ist, wird dieser in einer vom
  1012. *                 Nutzer anzugebenden Datei abgespeichert. Dabei wird ge-
  1013. *                 testet, ob die Datei bereits existiert. Falls ja, wird der
  1014. *                 Nutzer gefragt, ob er die Datei ueberschreiben moechte.
  1015. *
  1016. *****************************************************************************/
  1017.  
  1018. void do_blwrite()
  1019. {
  1020.   /* *** interne Daten *** */
  1021.   char name[MAXLENGTH+1]; /* Array fuer einzulesenden Filenamen */
  1022.   FILE *f;                /* Pointer fuer Datei, in die Block geschrieben */
  1023.               /* werden soll. */
  1024.   if (block_defined())    /* Nur, wenn Block markiert ist */
  1025.   {
  1026.     print_stat(PROMPT_FILENAME);
  1027.     read_stat(name,MAXLENGTH,GS_ANY); /* Filenamen einlesen */
  1028.     clear_stat();                     /* Statuszeile wieder loeschen */
  1029.     if(name[0])                       /* Name leer ? */
  1030.     {
  1031.       setz_cursor(W_AKT);                  /* Nein, Cursor plazieren */
  1032.  
  1033.       /* Falls Datei schon existiert, Sicherheitsabfrage vornehmen, ob    */
  1034.       /* der User die Datei ueberschreiben moechte. Existiert die Datei   */
  1035.       /* und der User moechte sie nicht ueberschreiben, wird die Funktion */
  1036.       /* beendet.                                                         */
  1037.  
  1038.       if(!access(name,0) && !ja_nein(PROMPT_FILEEXIST))
  1039.       {
  1040.     setz_cursor(W_AKT);
  1041.     return;
  1042.       }
  1043.       if (f = fopen (name,"w"))  /* Datei oeffnen */
  1044.       {                          /* Klappte das, Block mit save_... aus */
  1045.     if (akt_winp->block.typ == BT_RECHTECK) /* Text ausschneiden */
  1046.       akt_winp->block.bstart = save_rechteck();
  1047.     else
  1048.       akt_winp->block.bstart = save_normal();
  1049.     schr_block(akt_winp->block.bstart,f); /* Block in offene Datei */
  1050.     fclose (f);                  /* schreiben und Datei schliessen */
  1051.     block_free (akt_winp->block.bstart);    /* Blocktext freigeben */
  1052.       }
  1053.       else     /* Konnte Datei nicht geoeffnet werden, Fehlermeldung */
  1054.       {
  1055.     print_stat (PROMPT_ERRWRITE);
  1056.     pe_or(name);
  1057.       }
  1058.     }
  1059.     setz_cursor(W_AKT);
  1060.   }
  1061. }
  1062.  
  1063. /*****************************************************************************
  1064. *
  1065. *  Funktion       Zum Blockende gehen (do_goblend)
  1066. *  --------
  1067. *
  1068. *  Beschreibung : Falls der Blockanfang markiert ist, wird der Cursor dorthin
  1069. *                 gesetzt.
  1070. *
  1071. *****************************************************************************/
  1072.  
  1073. void do_goblend()
  1074. {
  1075.   if(akt_winp->block.e_line != -1)           /* Ist Blockende gesetzt ? */
  1076.   {
  1077.     akt_winp->lastline = akt_winp->textline; /* Ja, dann aktuelle Position */
  1078.     akt_winp->lastcol = akt_winp->screencol; /* als letzte Position merken */
  1079.     gotox(akt_winp->block.e_line);           /* Blockende anspringen */
  1080.     akt_winp->screencol = akt_winp->block.e_col;
  1081.     adapt_screen(" ");                     /* Fensterinhalt evtl. anpassen */
  1082.   }
  1083. }
  1084.  
  1085. /*****************************************************************************
  1086. *
  1087. *  Funktion       Zum Blockanfang (do_goblanf)
  1088. *  --------
  1089. *
  1090. *  Beschreibung : Falls der Blockanfang markiert ist, wird der Cursor dorthin
  1091. *                 gesetzt.
  1092. *
  1093. *****************************************************************************/
  1094.  
  1095. void do_goblanf()
  1096. {
  1097.   if(akt_winp->block.s_line != -1)           /* Blockanfang definiert ? */
  1098.   {
  1099.     akt_winp->lastline = akt_winp->textline; /* Aktuelle Position als   */
  1100.     akt_winp->lastcol = akt_winp->screencol; /* letzte Position merken  */
  1101.     gotox(akt_winp->block.s_line);           /* Blockanfang anspringen  */
  1102.     akt_winp->screencol = akt_winp->block.s_col;
  1103.     adapt_screen(" ");                  /* Evtl. Fensterinhalt anpassen */
  1104.   }
  1105. }
  1106.  
  1107. /*****************************************************************************
  1108. *
  1109. *  Funktion       Blockhervorhebungsmodus togglen (do_toghbl)
  1110. *  --------
  1111. *
  1112. *  Beschreibung : Das highblockflag wird getoggled. Dadurch wird die Darstel-
  1113. *                 lung eines markierten Blocks beeinflusst (gehighlighted oder
  1114. *                 nicht gehighlighted).
  1115. *
  1116. *****************************************************************************/
  1117.  
  1118. void do_toghbl()
  1119. {
  1120.   print_stat(PROMPT_BLKHILGHT); /* Meldung ueber den neuen Zustand */
  1121.   print_stat(on_off[highblockflag ^= TRUE]); /* ausgeben */
  1122.   sleep(1);
  1123.   /* Wenn ein Block markiert ist und dieser im Fenster sichtbar ist, */
  1124.   /* wird der Fensterinhalt neu dargestellt.                         */
  1125.   if(block_defined() && tst_overlap())
  1126.     sw_ohne_refresh(W_AKT);
  1127.   else         /* anderenfalls wird ein sleep ausgefuehrt, damit in bei- */
  1128.     sleep(1);  /* den Faellen die Meldung gleichlange zu lesen ist.      */
  1129.   clear_stat();
  1130.   setz_cursor(W_AKT);
  1131. }
  1132.  
  1133. /*****************************************************************************
  1134. *
  1135. *  Funktion       Block an Filter uebergeben (do_bltofil)
  1136. *  --------
  1137. *
  1138. *  Beschreibung : Falls ein Block markiert ist, wird dieser an ein vom Nutzer
  1139. *                 anzugebendes Filterprogramm uebergeben. Die Ausgabe des Fil-
  1140. *                 ters wird ueber eine Pipe eingelesen und als Block in den
  1141. *                 Text eingefuegt.
  1142. *
  1143. *****************************************************************************/
  1144.  
  1145. void do_bltofil()
  1146. {
  1147.   if (block_defined() && bl_to_fil())
  1148.   {
  1149.     if (akt_winp->textline < akt_winp->ws_line)  /* Falls Cursor durch das  */
  1150.       akt_winp->ws_line = akt_winp->textline;    /* Filtern des Blocks      */
  1151.     if (akt_winp->screencol < akt_winp->ws_col)  /* ausserhalb des Fensters */
  1152.       akt_winp->ws_col = akt_winp->screencol;    /* steht, Fenster anpassen */
  1153.     show_win(W_AKT);
  1154.   }
  1155. }
  1156.  
  1157. /*****************************************************************************
  1158. *
  1159. *  Funktion       Shellflag invertieren (do_shelltog)
  1160. *  --------
  1161. *
  1162. *  Beschreibung : Das shellflag der aktuellen Windowstruktur wird invertiert.
  1163. *
  1164. *****************************************************************************/
  1165.  
  1166. void do_shelltog()
  1167. {
  1168.   akt_winp->shellflag ^= TRUE;
  1169.   setz_cursor(W_AKT);      /* Kopfzeile aktualisieren */
  1170. }
  1171.  
  1172.  
  1173. /*****************************************************************************
  1174. *
  1175. *  Funktion       Marker setzen (do_setmarker)
  1176. *  --------
  1177. *
  1178. *  Beschreibung : Falls der Text nicht leer ist, wird der Nutzer nach der
  1179. *                 Markernummer (0-9) gefragt. Fuer den angegebenen Marker
  1180. *                 werden dann Position und Fensternummer gespeichert.
  1181. *
  1182. *****************************************************************************/
  1183.  
  1184. void do_setmarker()
  1185. {
  1186.   /* *** interne Daten *** */
  1187.   int m;   /* Nummer des gewuenschten Markers */
  1188.  
  1189.   if(akt_winp->maxline >= 0)  /* Text nicht leer ? */
  1190.   {
  1191.     if(helpflag)
  1192.       print_stat(PROMPT_MARKER);
  1193.     m = newwgetch(status) - '0'; /* Markernummer einlesen */
  1194.     if(helpflag)
  1195.       clear_stat();
  1196.     if(m >= 0 && m <= 9)         /* Bereich ueberpruefen */
  1197.     {
  1198.       marker[m].col = akt_winp->screencol; /* aktuelle Position und */
  1199.       marker[m].line = akt_winp->textline; /* Fensternummer eintragen */
  1200.       marker[m].window = akt_winp->wini;
  1201.       setz_cursor(W_AKT);
  1202.     }
  1203.     else                         /* Bereichspruefung schlug fehl */
  1204.       print_err(PROMPT_ERRMARKER);
  1205.   }
  1206. }
  1207.  
  1208. /*****************************************************************************
  1209. *
  1210. *  Funktion       Marker anspringen (do_jumpmarker)
  1211. *  --------
  1212. *
  1213. *  Beschreibung : Der Nutzer wird nach der Nummer des anzuspringenden Markers
  1214. *                 gefragt. Existiert der Marker, oder das zu dem Marker gehoe-
  1215. *                 rende fenster nicht mehr, so wird eine Meldung ausgegeben.
  1216. *                 Sonst wird das zum Marker gehoerige Fenster zum aktuellen
  1217. *                 Fenster, und der Cursor wird richtig positioniert.
  1218. *
  1219. *****************************************************************************/
  1220.  
  1221. void do_jumpmarker()
  1222. {
  1223.   /* *** interne Daten *** */
  1224.   int     m;        /* Nummer des gewuenschten Markers */
  1225.   win_typ *old_win; /* Zwischenspeicher fuer beim Aufruf aktuelles Fenster */
  1226.  
  1227.   if(helpflag)
  1228.     print_stat(PROMPT_MARKER);
  1229.   m = newwgetch(status) - '0';  /* Markernummer einlesen */
  1230.   if(helpflag)
  1231.     clear_stat();
  1232.   if(m >= 0 && m <= 9)          /* Bereichspruefung fuer Markernummer */
  1233.     if(marker[m].window != -1)  /* Ist Marker gesetzt ? */
  1234.     {
  1235.       kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1236.       rahmen(W_NOTAKT);
  1237.       wrefresh(akt_winp->winp);
  1238.  
  1239.       check_buff();             /* Pufferinhalt evtl. in Text eintragen */
  1240.       old_win = akt_winp;
  1241.       if(make_akt_win(marker[m].window)) /* zum Fenster gehen, in dem */
  1242.       {                                  /* der Marker gesetzt wurde  */
  1243.     akt_winp->lastcol  = akt_winp->screencol; /* aktuelle Position */
  1244.     akt_winp->lastline = akt_winp->textline; /*  als letzte merken */
  1245.  
  1246.     /* Steht der Marker hinter dem Textende, dann zur letzten Zeile  */
  1247.     /* gehen. Andernfalls die vom Marker angegebene Zeile anspringen */
  1248.     /* Falls Text leer, geht gotox richtig auf dummyp.               */
  1249.     gotox(akt_winp->maxline <= marker[m].line?akt_winp->maxline:marker[m].line);
  1250.     /* Falls Text leer, dann Spalte 0, sonst richtige Markerspalte */
  1251.     akt_winp->screencol = akt_winp->maxline>=0 ? marker[m].col : 0;
  1252.     if(old_win != akt_winp) /* Falls nicht aktuelles Fenster, dann */
  1253.       show_win(W_AKT);      /* Fensterkomplett neu zeichnen        */
  1254.     else
  1255.       rahmen(W_AKT);        /* Sonst Fenster wieder aktiv */
  1256.     adapt_screen(" ");      /* Fensterinhalt anpassen              */
  1257.       }
  1258.       else /* Fenster konnte nicht angesprungen werden, Meldung ausgeben */
  1259.     print_err(PROMPT_STALEMARK);
  1260.     }
  1261.     else
  1262.       print_err(PROMPT_EMPTYMARK);
  1263.   else
  1264.     print_err(PROMPT_ERRINPUT);
  1265. }
  1266.  
  1267. /*****************************************************************************
  1268. *
  1269. *  Funktion       Letzte Position anspringen (do_lastpos)
  1270. *  --------
  1271. *
  1272. *  Beschreibung : Es wird die letzte Position vor einem Find/Replace/Goto/
  1273. *                 lastpos/Marker angesprungen. Diese Position ist Fenster-
  1274. *                 intern.
  1275. *
  1276. *****************************************************************************/
  1277.  
  1278. void do_lastpos()
  1279. {
  1280.   /* *** interne Daten und Initialisierung *** */
  1281.   int hilf = akt_winp->textline; /* Zwischenspeicher fuer Zeilennummer */
  1282.  
  1283.   if(akt_winp->lastline != -1)   /* Letzte Position gesetzt ? */
  1284.   {
  1285.     /* aktuelle Spalte als letzte Spalte merken, letzte Spalte zur */
  1286.     /* aktuellen machen                                            */
  1287.     swap_int(&akt_winp->screencol,&akt_winp->lastcol);
  1288.     gotox(akt_winp->lastline);  /* Letzte Zeile anspringen */
  1289.     akt_winp->lastline = hilf;  /* Vorher aktuelle Zeile wird Letzte Z. */
  1290.     adapt_screen(" ");          /* Fensterinhalt anpassen */
  1291.   }
  1292. }
  1293.  
  1294. /*****************************************************************************
  1295. *
  1296. *  Funktion       Window gemaess Name anspringen (do_swname)
  1297. *  --------
  1298. *
  1299. *  Beschreibung : Der Nutzer kann einen Dateinamen eingeben. Falls die
  1300. *                 Nummer existiert, wird das Fenster mit diesem Namen
  1301. *                 zum aktuellen Fenster.
  1302. *
  1303. *****************************************************************************/
  1304.  
  1305. void do_swname()
  1306. {
  1307.   /* *** interne Daten und Initialisierung *** */
  1308.   char filename[MAXLENGTH+1]; /* Array fuer einzulesenden Filenamen    */
  1309.   int  wn = akt_winp->wini;   /* Zwischenspeicher fuer akt. Fensternr. */
  1310.  
  1311.   print_stat (PROMPT_FILENAME);
  1312.   read_stat (filename,MAXLENGTH,GS_ANY);  /* Filenamen einlesen */
  1313.   clear_stat();
  1314.   if(!filename[0])                        /* Filename leer ? */
  1315.   {
  1316.     setz_cursor(W_AKT);                        /* Dann verlassen */
  1317.     return;
  1318.   }
  1319.   kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1320.   rahmen(W_NOTAKT);
  1321.   wrefresh(akt_winp->winp);
  1322.  
  1323.   check_buff();               /* sonst Pufferinhalt evtl. in Text eintragen, */
  1324.   if (sw_name(filename))      /* versuchen, gewuenschtes Fenster zum aktu- */
  1325.   {                           /* ellen zu machen. */
  1326.     if(akt_winp->wini == wn)  /* War es das aktuelle Fenster ? */
  1327.     {
  1328.       rahmen(W_AKT);          /* Fenster wird evtl. wieder aktiv */
  1329.       setz_cursor(W_AKT);          /* Dann nur Cursor setzen */
  1330.     }
  1331.     else                      /* Sonst komplettes Fenster neu zeichnen */
  1332.       show_win(W_AKT);
  1333.   }
  1334.   else                        /* Fenster nicht gefunden */
  1335.     /* Abfragen, ob Datei geladen werden soll */
  1336.     if(ja_nein(PROMPT_NEWWINDOW))
  1337.     {
  1338.       kopf(W_NOTAKT);   /* Altes Fenster als inaktiv markieren */
  1339.       rahmen(W_NOTAKT);
  1340.       wrefresh(akt_winp->winp);
  1341.  
  1342.       if (koppel_win())   /* Soll Datei neu geladen werden, */
  1343.       {                   /* dann neues Fenster erzeugen */
  1344.     akt_winp->filename = save_text(filename); /* Filenamen eintragen */
  1345.     if (!lies_file())  /* Datei in neues Fenster einlesen */
  1346.     {
  1347.       gb_win_frei();   /* Klappte das nicht, Fenster wieder loeschen, */
  1348.       rahmen(W_AKT);   /* Fenster highlighten */
  1349.       setz_cursor(W_AKT);   /* und Cursor an richtige Position */
  1350.     }
  1351.     else               /* Sonst Fensterwerte initialisieren */
  1352.       open_window();
  1353.       }
  1354.       else                 /* koppel_win klappte nicht */
  1355.       {
  1356.     pe_or("Zu viele Fenster! ");
  1357.     rahmen(W_AKT); /* Altes Fenster wieder aktiv */
  1358.     setz_cursor(); /* Cursor an richtige Position */
  1359.       }
  1360.     }
  1361.     else                   /* Fenster nicht gefunden, Datei soll aber */
  1362.     {
  1363.       rahmen(W_AKT);       /* Fenster highlighten */
  1364.       setz_cursor(W_AKT);       /* auch nicht neu geladen werden */
  1365.     }
  1366. }
  1367.  
  1368. /*****************************************************************************
  1369. *
  1370. *  Funktion       Datei unter neuem Namen abspeichern (do_newname)
  1371. *  --------
  1372. *
  1373. *  Beschreibung : Der Dateiname der Datei im aktuellen Fenster wird intern
  1374. *                 geaendert und der Text unter dem neuen Namen abgespeichert.
  1375. *
  1376. *****************************************************************************/
  1377.  
  1378. void do_newname()
  1379. {
  1380.   /* *** interne Daten *** */
  1381.   char name[MAXLENGTH+1];  /* Array fuer einzulesenden neuen Namen */
  1382.  
  1383.   print_stat(PROMPT_FILENAME);
  1384.   read_stat(name,MAXLENGTH,GS_ANY); /* Dateinamen einlesen */
  1385.   clear_stat();
  1386.   if(!name[0])                      /* Leerer Name, dann raus */
  1387.   {
  1388.     pos_cursor();
  1389.     return;
  1390.   }
  1391.   free(akt_winp->filename);         /* Sonst alten Namen freigeben       */
  1392.   akt_winp->attribs = STD_FATTR;    /* Attribute und read_only-Status    */
  1393.   akt_winp->read_only = FALSE;      /* initialisieren                    */
  1394.   akt_winp->filename = save_text(name); /* Neuen Namen abspeichern       */
  1395.   schreib_file();                   /* Datei unter neuem Namen speichern */
  1396.   setz_cursor(W_AKT);
  1397. }
  1398.  
  1399. /*****************************************************************************
  1400. *
  1401. *  Funktion       Macro definieren/ausfuehren (do_macro)
  1402. *  --------
  1403. *
  1404. *  Beschreibung : Nach Eingabe eines Grossbuchstabens kann der Benutzer
  1405. *                 einen Macro definieren, indem er die dem Macro zuzu-
  1406. *                 ordnenden Tasten drueckt. Beendet wird die Macrodefinition
  1407. *                 durch Druck der ESCAPE-Taste (get_comstr()).
  1408. *                 Nach Eingabe eines Kleinbuchstabens wird der entsprechende
  1409. *                 Macro - falls definiert - aufgerufen.
  1410. *
  1411. *****************************************************************************/
  1412.  
  1413. void do_macro()
  1414. {
  1415.   /* *** interne Daten *** */
  1416.   short int mnum;  /* Zum einlesen des Macrobuchstabens */
  1417.  
  1418.   if(helpflag)
  1419.     print_stat(PROMPT_MACRO);
  1420.   mnum = newwgetch(status);  /* Macrobuchstaben einlesen */
  1421.   if(helpflag)
  1422.     clear_stat();
  1423.   if(mnum>='A' && mnum<='Z') /* Macro definieren ? */
  1424.   {
  1425.     mnum -= 'A';
  1426.     line_free(macro[mnum].begin); /* vorherigen Macrotext freigeben */
  1427.     get_comstr(¯o[mnum].begin,¯o[mnum].end); /* und neuen einlesen */
  1428.   }
  1429.   else                       /* Macro ausfuehren */
  1430.     exec_macro(mnum);
  1431.   setz_cursor(W_AKT);
  1432. }
  1433.  
  1434. /*****************************************************************************
  1435. *
  1436. *  Funktion       Geloeschte Zeile wiederherstellen (do_restline)
  1437. *  --------
  1438. *
  1439. *  Beschreibung : Mittels rest_delline() wird die zuletzt geloeschte Zeile
  1440. *                 bzw. eine Leerzeile vor der aktuellen Zeile eingefuegt.
  1441. *
  1442. *****************************************************************************/
  1443.  
  1444. void do_restline()
  1445. {
  1446.   if(akt_winp->maxline < MAX_ANZ_LINES-1) /* noch Platz da? */
  1447.   {
  1448.     rest_delline();
  1449.     show_win(W_AKT);
  1450.   }
  1451.   else                /* Kein Platz mehr, Fehlermeldung ausgeben */
  1452.     print_err(T_SIZE_ERRTEXT);
  1453. }
  1454.  
  1455. void (*funktion [])() = {do_refresh, do_bol,do_eol,do_halfup,do_halfdn,do_delete,
  1456.              do_backspace,do_home,do_nothome,do_insovr,do_textbeginn,
  1457.              do_eot,do_del_word,do_wleft,do_wright,do_right,do_left,
  1458.              do_up,do_down,do_pgup,do_pgdn,do_newline,do_delline,
  1459.              ueberschreiben,do_schreib_file,quit,do_control,do_help,
  1460.              do_movewin,do_sizewin,do_swnext,do_swprev,do_swnum,
  1461.              laden,do_win_zu,do_goto,do_ende,do_find,do_replace,
  1462.              do_underline,do_z_hoch,do_z_runter,do_z_oben,
  1463.              do_z_mitte,do_z_unten,do_deleol,do_toggle_size,
  1464.              do_repfr,do_repeat,do_repfr,do_join,do_open,do_tog_ai,
  1465.              do_tab,do_settab,do_tog_tkm,do_blstart,do_blnormend,
  1466.              do_blrechtend,do_blunmark,do_blweg,do_blcopy,
  1467.              do_blmove,do_blcut,do_blpaste,do_blindent,do_blread,
  1468.              do_blwrite,do_goblend,do_goblanf,do_toghbl,do_bltofil,
  1469.              do_setmarker,do_jumpmarker,do_lastpos,do_hopen,
  1470.              do_swname,do_newname,do_backtab,do_tog_bak,do_macro,
  1471.              do_restline,do_shelltog,do_endemit,quitmit,do_delete,
  1472.              do_inschar };
  1473.  
  1474. /*****************************************************************************
  1475. *
  1476. *  Funktion       Tastendruck auswerten (auswertung)
  1477. *  --------
  1478. *
  1479. *  Parameter    : t         :
  1480. *                   Typ          : int
  1481. *                   Wertebereich : 0-MAX_COMM_INDEX
  1482. *                   Bedeutung    : Nummer des Befehls. Ist t == BUCHSTABE,
  1483. *                                  dann steht der Buchstabe in letter.
  1484. *
  1485. *  Beschreibung : Anhand des Kommandos wird eine Funktion aufgerufen, die
  1486. *                 den Befehl ausfuehrt.
  1487. *
  1488. *****************************************************************************/
  1489.  
  1490. void auswertung (t)
  1491. int t;
  1492. {
  1493.   hide_show(FALSE); /* Maus vor Ausführung der Operation verstecken */
  1494.   (*funktion[t])();
  1495.   hide_show(TRUE);  /* Maus nach der Operation wieder anzeigen */
  1496. }
  1497.